package com.springboot.util;///****************************************************
// * 创建人：     @author hechengcheng
// * 创建时间: 2019年5月29日/下午4:53:36
// * 项目名称：  dfas-common-util
// * 文件名称: ListUtil.java
// * 文件描述: @Description: 对象拷贝或转换工具类
// *
// * All rights Reserved, Designed By 投资交易团队
// * @Copyright:2019-2030
// *
// ********************************************************/
//
//package src.util;
//
//import cn.hutool.core.bean.BeanUtil;
//import cn.hutool.core.collection.CollUtil;
//import cn.hutool.core.collection.CollectionUtil;
//import cn.hutool.core.exceptions.ExceptionUtil;
//import cn.hutool.core.util.ObjectUtil;
//import cn.hutool.core.util.StrUtil;
//import com.alibaba.fastjson.JSON;
//import com.github.pagehelper.PageInfo;
//import com.google.common.collect.Lists;
//import com.google.common.collect.Maps;
//import com.win.dfas.common.annotation.WinFormat;
//import com.win.dfas.common.annotation.WinFormatReverse;
//import com.win.dfas.common.constant.CommonConstants;
//import com.win.dfas.common.enumeration.CommonExceptionEnum;
//import com.win.dfas.common.enumeration.FormatEnum;
//import com.win.dfas.common.exception.IExceptionEnum;
//import com.win.dfas.common.exception.WinException;
//import com.win.dfas.common.util.RedisUtil;
//import com.win.dfas.common.util.ReflectUtil;
//import com.win.dfas.common.util.WinExceptionUtil;
//import lombok.extern.slf4j.Slf4j;
//import org.slf4j.Logger;
//import org.slf4j.LoggerFactory;
//import org.springframework.beans.BeanUtils;
//import org.springframework.cglib.beans.BeanGenerator;
//import org.springframework.cglib.beans.BeanMap;
//
//import java.io.*;
//import java.lang.reflect.Field;
//import java.util.*;
//import java.util.function.Consumer;
//import java.util.stream.Collectors;
//
///**
// * 包名称： com.win.dfas.common.util
// * 类名称：ListUtil
// * 类描述：对象拷贝或转换工具类
// * 创建人：@author hechengcheng
// * 创建时间：2019年5月29日/下午4:53:36
// */
//@Slf4j
//public final class ObjectUtils {
//
//    private static final Logger LOGGER = LoggerFactory.getLogger(ObjectUtils.class);
//
//    /**
//     * List对象转换
//     *
//     * @param sourceList 源对象
//     * @param clazz      新对象类型
//     * @return
//     * @throws
//     * @Title: copyPropertiesList
//     * @return: List<?>  转换后List对象
//     * @author: hechengcheng
//     * @Date: 2019年5月29日/下午5:41:06
//     */
//    public static <T> List<T> copyPropertiesList(List<?> sourceList, Class<T> clazz) {
//
//        List<T> resultList = new ArrayList<T>();
//
//        resultList = copyPropertiesList(sourceList, clazz, false);
//
//        return (List<T>) resultList;
//    }
//
//    /**
//     * List对象转换
//     *
//     * @param sourceList 源对象
//     * @param clazz      新对象类型
//     * @param format     是否格式化
//     * @return
//     * @throws
//     * @Title: copyPropertiesList
//     * @return: List<T>   转换后List对象
//     * @author: hechengcheng
//     * @Date: 2019年8月6日/上午10:51:24
//     */
//    public static <T> List<T> copyPropertiesList(List<?> sourceList, Class<T> clazz, boolean format) {
//
//        List<T> resultList = new ArrayList<T>();
//
//        try {
//            if (sourceList == null || sourceList.size() == 0) {
//                return resultList;
//            }
//
//            for (Object source : sourceList) {
//                T target = clazz.newInstance();
//                BeanUtil.copyProperties(source, target);
//                resultList.add(target);
//            }
//
//            // 格式化数据
//            if (format) {
//                formatList(resultList, clazz);
//            }
//
//        } catch (InstantiationException e) {
//            e.printStackTrace();
//        } catch (IllegalAccessException e) {
//            e.printStackTrace();
//        }
//
//        return (List<T>) resultList;
//    }
//
//    /**
//     * 分页对象拷贝
//     *
//     * @param sourcePageInfo 源分页对象
//     * @param clazz          目标分页对象中List的对象类型
//     * @return
//     * @throws
//     * @Title: copyPageInfo
//     * @return: PageInfo<T>  转换后的分页对象
//     * @author: hechengcheng
//     * @Date: 2019年6月6日/下午1:17:29
//     */
//    public static <T> PageInfo<T> copyPageInfo(PageInfo<?> sourcePageInfo, Class<T> clazz) {
//
//        PageInfo<T> resultPageInfo = new PageInfo<T>();
//
//        // 分页对象拷贝
//        resultPageInfo = copyPageInfo(sourcePageInfo, clazz, false);
//
//        return (PageInfo<T>) resultPageInfo;
//
//    }
//
//    /**
//     * 分页对象拷贝
//     *
//     * @param sourcePageInfo 源分页对象
//     * @param clazz          目标分页对象中List的对象类型
//     * @param format         是否格式化
//     * @return
//     * @throws
//     * @Title: copyPageInfo
//     * @return: PageInfo<T>
//     * @author: hechengcheng
//     * @Date: 2019年8月6日/上午10:54:20
//     */
//    public static <T> PageInfo<T> copyPageInfo(PageInfo<?> sourcePageInfo, Class<T> clazz, boolean format) {
//
//        PageInfo<T> resultPageInfo = new PageInfo<T>();
//
//        try {
//            if (sourcePageInfo == null) {
//                return resultPageInfo;
//            }
//
//            // 拷贝PageInfo对象(排除list)
//            BeanUtils.copyProperties(sourcePageInfo, resultPageInfo, "list");
//
//            List<?> sourceList = sourcePageInfo.getList();
//
//            // 拷贝PageInfo对象中的list
//            List<T> targetLsit = copyPropertiesList(sourceList, clazz);
//
//            // 数据格式化
//            if (format) {
//                formatList(targetLsit, clazz);
//            }
//
//            resultPageInfo.setList(targetLsit);
//        } catch (Exception e) {
//            e.printStackTrace();
//        }
//
//        return (PageInfo<T>) resultPageInfo;
//
//    }
//
//    /**
//     * 对象深度克隆
//     *
//     * @param srcObj 源对象
//     * @return
//     * @throws
//     * @Title: clone
//     * @return: Object 克隆对象
//     * @author: hechengcheng
//     * @Date: 2019年5月29日/下午5:52:49
//     */
//    public static Object clone(Object srcObj) {
//
//        Object cloneObj = null;
//        ObjectOutputStream oos = null;
//        ObjectInputStream ois = null;
//
//        try {
//            ByteArrayOutputStream baos = new ByteArrayOutputStream();
//            oos = new ObjectOutputStream(baos);
//            oos.writeObject(srcObj);
//
//            ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray());
//            ois = new ObjectInputStream(bais);
//            cloneObj = ois.readObject();
//
//            baos.close();
//            bais.close();
//        } catch (Exception e) {
//            e.printStackTrace();
//        } finally {
//            try {
//                oos.close();
//                ois.close();
//            } catch (IOException e) {
//                e.printStackTrace();
//            }
//        }
//
//        return cloneObj;
//    }
//
//    /**
//     * 根据自定义规则格式化列表数据
//     *
//     * @param sourceList
//     * @param clazz
//     * @throws
//     * @Title: formatList
//     * @return: void
//     * @author: hechengcheng
//     * @Date: 2019年8月5日/下午8:11:33
//     */
//    @Deprecated
//    public static void formatListBySingle(List<?> sourceList, Class<?> clazz) {
//        long startMillis = System.currentTimeMillis();
//
//        if (CollectionUtil.isEmpty(sourceList) || ObjectUtil.isEmpty(clazz)) {
//            return;
//        }
//
//        // 获取注解属性
//        Map<Field, Field> annoFieldMap = getWinFormatField(clazz);
//
//        if (CollectionUtil.isEmpty(annoFieldMap)) {
//            return;
//        }
//
//        // 遍历格式化数据(并发处理)
//        sourceList.parallelStream().forEach((sourceObject) -> {
//            formatObjectByAnnotation(sourceObject, clazz, annoFieldMap);
//        });
//
//        log.debug("formatListBySingle, cost millisecond is {}, data size is {}", (System.currentTimeMillis() - startMillis), sourceList.size());
//    }
//
//    /**
//     *
//     * @Title: formatList
//     * @Description: 根据自定义规则格式化列表数据
//     * @param sourceList
//     * @param clazz
//     * @return: void
//     * @throws
//     * @author: hechengcheng
//     * @Date:  2020年9月18日/上午11:03:50
//     */
//    public static void formatList(List<?> sourceList, Class<?> clazz) {
//
//        long startMillis = System.currentTimeMillis();
//
//        if (CollectionUtil.isEmpty(sourceList) || ObjectUtil.isEmpty(clazz)) {
//            return;
//        }
//
//        // 获取注解属性 filed -> fromFiled
//        Map<Field, Field> annoFieldMap = getWinFormatField(clazz);
//
//        if (CollectionUtil.isEmpty(annoFieldMap)) {
//            return;
//        }
//
//        List<String> redisKeyList = new ArrayList<String>(18);
//
//        // 获取所有的Key
//        sourceList.stream().forEach(source -> {
//            for (Map.Entry<Field, Field> entry : annoFieldMap.entrySet()) {
//                try {
//                    // 需要格式化的属性
//                    Field formatField = entry.getKey();
//
//                    // 获取格式化属性注解
//                    WinFormat winFormat = formatField.getAnnotation(WinFormat.class);
//
//                    // 格式化数据来源属性
//                    Field fromField = entry.getValue();
//
//                    // 设置可访问
//                    formatField.setAccessible(true);
//
//                    if (ObjectUtil.isNotEmpty(fromField)) {
//                        fromField.setAccessible(true);
//                    }
//
//                    Object fromFieldValue = null;
//
//                    // 获取数据来源属性值
//                    if (winFormat.fromField().indexOf(CommonConstants.DOT) < 0) {
//                        fromFieldValue = fromField.get(source);
//                    } else {
//                        // 多层级结构遍历获取
//                        fromFieldValue = ReflectUtil.getFieldObject(source, winFormat.fromField());
//                    }
//
//                    if (ObjectUtil.isEmpty(fromFieldValue)) {
//                        continue;
//                    }
//
//                    // 转换列表
//                    List<Object> separatorList = new ArrayList<Object>();
//
//                    // 分隔符处理
//                    if (StrUtil.isNotEmpty(winFormat.separator())) {
//                        separatorList.addAll(Arrays.asList(((String)fromFieldValue).split(winFormat.separator())));
//                    } else {
//                        separatorList.add(fromFieldValue);
//                    }
//
//                    // 参数对象处理
//                    Object[] paramObjects = new Object[winFormat.prefixParam().length + 1];
//                    if (winFormat.prefixParam().length > 0) {
//                        System.arraycopy(winFormat.prefixParam(), 0, paramObjects, 0, paramObjects.length - 1);
//                    }
//
//                    // 转换列表处理
//                    separatorList.forEach(item -> {
//                        paramObjects[paramObjects.length - 1] = item;
//
//                        // 获取注解枚举
//                        FormatEnum formatEnum = winFormat.value();
//
//                        // 获取REDIS对应的值
//                        String formatKey = formatEnum.getType() + formatEnum.getFormat();
//
//                        String redisKey = String.format(formatKey, paramObjects);
//
//                        redisKeyList.add(redisKey);
//                    });
//                } catch (Exception e) {
//                    e.printStackTrace();
//                }
//            }
//
//        });
//
//        // 批量获取数据
//        //处理sourceList数据量过大的场景：分批次调用mget
//        List<Object> redisObjectList = new LinkedList<>();
//        int batchSize = 1000*10;//每次查询1万个key，保证基本需求一次请求就能够处理。数据量大时，1万key的mget也不至于消耗太多时间
//        for (int i = 0; i < redisKeyList.size(); i += batchSize) {
//            redisObjectList.addAll(RedisUtil.multiGet(redisKeyList.subList(i, i + batchSize > redisKeyList.size() ? redisKeyList.size() : i + batchSize)));
//        }
//
//        // log.debug("formatList, RedisUtil multiGet cost millisecond is {}, data size is {}", (System.currentTimeMillis() - startMillis), sourceList.size());
//
//        // 数据索引
//        int redisObjectIndex = 0;
//
//        // 设置对象属性
//        for (Object source : sourceList) {
//
//            for (Map.Entry<Field, Field> entry : annoFieldMap.entrySet()) {
//
//                try {
//                    // 需要格式化的属性
//                    Field formatField = entry.getKey();
//
//                    formatField.setAccessible(true);
//
//                    // 获取格式化属性注解
//                    WinFormat winFormat = formatField.getAnnotation(WinFormat.class);
//
//                    // 格式化数据来源属性
//                    Field fromField = entry.getValue();
//
//                    // 设置可访问
//                    formatField.setAccessible(true);
//
//                    if (ObjectUtil.isNotEmpty(fromField)) {
//                        fromField.setAccessible(true);
//                    }
//
//                    Object fromFieldValue = null;
//
//                    // 获取数据来源属性值
//                    if (winFormat.fromField().indexOf(CommonConstants.DOT) < 0) {
//                        fromFieldValue = fromField.get(source);
//                    } else {
//                        // 多层级结构遍历获取
//                        fromFieldValue = ReflectUtil.getFieldObject(source, winFormat.fromField());
//                    }
//
//                    // 源值为空
//                    if (ObjectUtil.isEmpty(fromFieldValue)) {
//                        continue;
//                    }
//
//                    // 需要转义的数量
//                    int valueCount = 1;
//
//                    // 分隔符处理
//                    if (StrUtil.isNotEmpty(winFormat.separator())) {
//                        valueCount = StrUtil.split(fromFieldValue.toString(), winFormat.separator()).length;
//                    }
//
//                    // 转义值
//                    StringBuffer valueBuffer = new StringBuffer();
//
//                    for (int j = 0; j < valueCount; j++) {
//                        Object redisOjbect = redisObjectList.get(redisObjectIndex);
//
//                        // REDIS值转换
//                        @SuppressWarnings("unchecked")
//                        Map<String, Object> redisMap = JSON.parseObject(JSON.toJSONString(redisOjbect), Map.class);
//                        if (ObjectUtil.isEmpty(redisMap)) {
//                            redisObjectIndex++;
//                            continue;
//                        }
//
//                        // 获取解析值
//                        String valueKey = String.format(winFormat.value().getKey());
//
//                        if (StrUtil.isEmpty(valueKey)) {
//                            valueKey = winFormat.redisValueKey();
//                        }
//
//                        // 兼容Oracle(Oracle列名自动转换为大写)
//                        Object redisMapValue = redisMap.getOrDefault(valueKey, redisMap.get(valueKey.toUpperCase()));
//
//                        // 处理分隔符
//                        if (StrUtil.isNotEmpty(valueBuffer) && StrUtil.isNotEmpty(winFormat.separator())) {
//                            valueBuffer.append(winFormat.separator());
//                        }
//
//                        valueBuffer.append(redisMapValue);
//
//                        redisObjectIndex++;
//                    }
//
//                    // 设置属性值
//                    if (StrUtil.isNotEmpty(valueBuffer)) {
//                        formatField.set(source, valueBuffer.toString());
//                    }
//
//                } catch (NoSuchFieldException e) {
//                    LOGGER.error(ExceptionUtil.stacktraceToString(e));
//                    throw WinExceptionUtil.winException(CommonExceptionEnum.FORMAT_EXCEPTION);
//                } catch (IllegalArgumentException e) {
//                    LOGGER.error(ExceptionUtil.stacktraceToString(e));
//                    throw WinExceptionUtil.winException(CommonExceptionEnum.FORMAT_EXCEPTION);
//                } catch (IllegalAccessException e) {
//                    LOGGER.error(ExceptionUtil.stacktraceToString(e));
//                    throw WinExceptionUtil.winException(CommonExceptionEnum.FORMAT_EXCEPTION);
//                }
//            }
//        }
//
//        log.debug("formatList, cost millisecond is {}, data size is {}", (System.currentTimeMillis() - startMillis), sourceList.size());
//    }
//
//    /**
//     * 根据自定义规则逆向格式化列表数据
//     *
//     * @param sourceList
//     * @param clazz
//     * @throws
//     * @Title: formatListReverse
//     * @return: void
//     * @author: zhaokai
//     * @Date: 2020年9月16日/下午8:11:33
//     */
//    public static void formatListReverse(List<?> sourceList, Class<?> clazz) {
//
//        if (CollectionUtil.isEmpty(sourceList) || ObjectUtil.isEmpty(clazz)) {
//            return;
//        }
//
//        // 获取注解属性
//        Map<Field, Field> annoFieldMap = getWinFormatReverseField(clazz);
//
//        if (CollectionUtil.isEmpty(annoFieldMap)) {
//            return;
//        }
//
//        // 遍历格式化数据(并发处理)
//        sourceList.parallelStream().forEach((sourceObject) -> {
//            formatObjectByAnnotationReverse(sourceObject, clazz, annoFieldMap);
//        });
//    }
//
//
//    /**
//     * 根据自定义规则格式化数据
//     *
//     * @param sourceObject
//     * @param clazz
//     * @throws
//     * @Title: formatObject
//     * @return: void
//     * @author: hechengcheng
//     * @Date: 2019年8月6日/上午10:42:13
//     */
//    public static void formatObject(Object sourceObject, Class<?> clazz) {
//
//        if (ObjectUtil.isEmpty(sourceObject) || ObjectUtil.isEmpty(clazz)) {
//            return;
//        }
//
//        // 获取注解属性
//        Map<Field, Field> annoFieldMap = getWinFormatField(clazz);
//
//        if (CollectionUtil.isEmpty(annoFieldMap)) {
//            return;
//        }
//
//        List<Object> list = new ArrayList<Object>() {
//            private static final long serialVersionUID = 1L;
//            {
//                add(sourceObject);
//            }};
//
//        // 格式化数据
//        formatList(list, clazz);
//    }
//
//    /**
//     * 根据自定义规则格式化数据
//     *
//     * @param sourceObject 格式化对象
//     * @param clazz        格式化对象类
//     * @param annoFiedlMap 注解属性键值对
//     * @throws
//     * @Title: formatObjectByAnnotation
//     * @return: void
//     * @author: hechengcheng
//     * @Date: 2019年8月6日/上午10:42:39
//     */
//    @Deprecated
//    private static void formatObjectByAnnotation(Object sourceObject, Class<?> clazz, Map<Field, Field> annoFiedlMap) {
//
//        try {
//
//            if (CollectionUtil.isEmpty(annoFiedlMap)) {
//                return;
//            }
//
//            // 遍历设置属性值
//            for (Map.Entry<Field, Field> entry : annoFiedlMap.entrySet()) {
//
//                // 需要格式化的属性
//                Field formatField = entry.getKey();
//
//                // 获取格式化属性注解
//                WinFormat winFormat = formatField.getAnnotation(WinFormat.class);
//
//                // 格式化数据来源属性
//                Field fromField = entry.getValue();
//
//                // 设置可访问
//                formatField.setAccessible(true);
//
//                if (ObjectUtil.isNotEmpty(fromField)) {
//                    fromField.setAccessible(true);
//                }
//
//                Object fromFieldValue = null;
//
//                // 获取数据来源属性值
//                if (winFormat.fromField().indexOf(CommonConstants.DOT) < 0) {
//                    fromFieldValue = fromField.get(sourceObject);
//                } else {
//                    // 多层级结构遍历获取
//                    fromFieldValue = ReflectUtil.getFieldObject(sourceObject, winFormat.fromField());
//                }
//
//                if (ObjectUtil.isEmpty(fromFieldValue)) {
//                    continue;
//                }
//
//                List<Object> toTransObjs = new LinkedList<>();
//                if (!StrUtil.isEmpty(winFormat.separator())) {//多值转换，源值为String
//                    toTransObjs.addAll(Arrays.asList(((String)fromFieldValue).split(winFormat.separator())));
//                }else {
//                    toTransObjs.add(fromFieldValue);
//                }
//
//                // 参数对象处理
//                Object[] paramObjects = new Object[winFormat.prefixParam().length + 1];
//                if (winFormat.prefixParam().length > 0) {
//                    System.arraycopy(winFormat.prefixParam(), 0, paramObjects, 0, paramObjects.length - 1);
//                }
//                Set<String> keys = new HashSet<>();
//                //生成key
//                toTransObjs.forEach(item -> {
//                    paramObjects[paramObjects.length - 1] = item;
//
//                    // 获取注解枚举
//                    FormatEnum formatEnum = winFormat.value();
//
//                    // 获取REDIS对应的值
//                    String formatKey = formatEnum.getType() + formatEnum.getFormat();
//
//                    keys.add(String.format(formatKey, paramObjects));
//                });
//
//                StringBuilder transResult = new StringBuilder();
//                RedisUtil.multiGet(keys).forEach(result -> {
//                    if (ObjectUtil.isEmpty(result)) {
//                        return;
//                    }
//                    // REDIS值转换
//                    @SuppressWarnings("unchecked")
//                    Map<String, Object> redisMap = JSON.parseObject(JSON.toJSONString(result), Map.class);
//                    if (ObjectUtil.isEmpty(redisMap)) {
//                        return;
//                    }
//
//                    // 获取解析值
//                    String valueKey = String.format(winFormat.value().getKey());
//
//                    // 兼容Oracle(Oracle列名自动转换为大写)
//                    Object redisMapValue = redisMap.getOrDefault(valueKey, redisMap.get(valueKey.toUpperCase()));
//
//                    if (ObjectUtil.isEmpty(redisMapValue)) {
//                        return;
//                    }
//
//                    transResult.append(transResult.length() > 0 ? winFormat.separator() : "").append(String.valueOf(redisMapValue));
//                });
//
//                if (0 == transResult.length()) {
//                    continue;
//                }
//
//                // 设置属性值，属性值固定为String
//                formatField.set(sourceObject, transResult.toString());
//            }
//        } catch (NoSuchFieldException e) {
//            LOGGER.error(ExceptionUtil.stacktraceToString(e));
//            throw WinExceptionUtil.winException(CommonExceptionEnum.FORMAT_EXCEPTION);
//        } catch (IllegalArgumentException e) {
//            LOGGER.error(ExceptionUtil.stacktraceToString(e));
//            throw WinExceptionUtil.winException(CommonExceptionEnum.FORMAT_EXCEPTION);
//        } catch (IllegalAccessException e) {
//            LOGGER.error(ExceptionUtil.stacktraceToString(e));
//            throw WinExceptionUtil.winException(CommonExceptionEnum.FORMAT_EXCEPTION);
//        }
//    }
//
//    /**
//     * 根据自定义规则逆向格式化数据
//     *
//     * @param sourceObject 格式化对象
//     * @param clazz        格式化对象类
//     * @param annoFiedlMap 注解属性键值对
//     * @throws
//     * @Title: formatObjectByAnnotationReverse
//     * @return: void
//     * @author: zhaokai
//     * @Date: 2020年9月16日/下午8:11:33
//     */
//    private static void formatObjectByAnnotationReverse(Object sourceObject, Class<?> clazz, Map<Field, Field> annoFiedlMap) {
//
//        try {
//
//            if (CollectionUtil.isEmpty(annoFiedlMap)) {
//                return;
//            }
//
//            // 遍历设置属性值
//            for (Map.Entry<Field, Field> entry : annoFiedlMap.entrySet()) {
//
//                // 需要格式化的属性
//                Field formatField = entry.getKey();
//
//                // 获取格式化属性注解
//                WinFormatReverse winFormatReverse = formatField.getAnnotation(WinFormatReverse.class);
//
//                // 格式化数据来源属性
//                Field fromField = entry.getValue();
//
//                // 设置可访问
//                formatField.setAccessible(true);
//
//                if (ObjectUtil.isNotEmpty(fromField)) {
//                    fromField.setAccessible(true);
//                }
//
//                Object fromFieldValue = null;
//
//                // 获取数据来源属性值
//                if (winFormatReverse.fromField().indexOf(CommonConstants.DOT) < 0) {
//                    fromFieldValue = fromField.get(sourceObject);
//                } else {
//                    // 多层级结构遍历获取
//                    fromFieldValue = ReflectUtil.getFieldObject(sourceObject, winFormatReverse.fromField());
//                }
//
//                if (ObjectUtil.isEmpty(fromFieldValue)) {
//                    continue;
//                }
//
//                List<Object> toTransObjs = new LinkedList<>();
//                if (!StrUtil.isEmpty(winFormatReverse.separator())) {//多值转换，源值为String
//                    toTransObjs.addAll(Arrays.asList(((String)fromFieldValue).split(winFormatReverse.separator())));
//                }else {
//                    toTransObjs.add(fromFieldValue);
//                }
//
//                // 参数对象处理
//                Object[] paramObjects = new Object[winFormatReverse.prefixParam().length + 1];
//                if (winFormatReverse.prefixParam().length > 0) {
//                    System.arraycopy(winFormatReverse.prefixParam(), 0, paramObjects, 0, paramObjects.length - 1);
//                }
//                //生成key
//                // 获取注解枚举
//                FormatEnum formatEnum = winFormatReverse.value();
//                Set<String> keys = RedisUtil.getKeys(formatEnum.getType() + "-" + paramObjects[0].toString() + "*");
//
//                StringBuilder transResult = new StringBuilder();
//                Object finalFromFieldValue = fromFieldValue;
//                RedisUtil.multiGet(keys).forEach(result -> {
//                    if (ObjectUtil.isEmpty(result)) {
//                        return;
//                    }
//                    // REDIS值转换
//                    @SuppressWarnings("unchecked")
//                    Map<String, Object> redisMap = JSON.parseObject(JSON.toJSONString(result), Map.class);
//                    if (ObjectUtil.isEmpty(redisMap)) {
//                        return;
//                    }
//
//                    // 获取解析值
//                    String valueKey = String.format(winFormatReverse.value().getKey());
//
//                    // 兼容Oracle(Oracle列名自动转换为大写)
//                    Object redisMapValue = redisMap.getOrDefault(valueKey, redisMap.get(valueKey.toUpperCase()));
//
//                    if (ObjectUtil.isEmpty(redisMapValue) || !redisMapValue.equals(finalFromFieldValue)) {
//                        return;
//                    }
//
//                    Object redisMapDicCode = redisMap.getOrDefault("dicCode", redisMap.get("dicCode".toUpperCase()));
//
//                    transResult.append(transResult.length() > 0 ? winFormatReverse.separator() : "").append(String.valueOf(redisMapDicCode));
//                });
//
//                if (0 == transResult.length()) {
//                    continue;
//                }
//
//                // 设置属性值，属性值固定为String
//                formatField.set(sourceObject, transResult.toString());
//            }
//        } catch (NoSuchFieldException e) {
//            LOGGER.error(ExceptionUtil.stacktraceToString(e));
//            throw WinExceptionUtil.winException(CommonExceptionEnum.FORMAT_EXCEPTION);
//        } catch (IllegalArgumentException e) {
//            LOGGER.error(ExceptionUtil.stacktraceToString(e));
//            throw WinExceptionUtil.winException(CommonExceptionEnum.FORMAT_EXCEPTION);
//        } catch (IllegalAccessException e) {
//            LOGGER.error(ExceptionUtil.stacktraceToString(e));
//            throw WinExceptionUtil.winException(CommonExceptionEnum.FORMAT_EXCEPTION);
//        }
//    }
//
//    /**
//     *
//     * @Title: generateObjectByField
//     * @Description: 根据属性映射构建对象
//     * @param propertyMap
//     * @return
//     * @return: Object
//     * @throws
//     * @author: hechengcheng
//     * @Date:  2020年7月11日/下午1:20:21
//     */
//    public static Object generateObjectByField(Map<String, Object> propertyMap) {
//
//        if (ObjectUtil.isEmpty(propertyMap)) {
//            return null;
//        }
//
//        String proxyPrefix = "$cglib_prop_";
//
//        BeanGenerator generator = new BeanGenerator();
//
//        for (Map.Entry<String, Object> entry : propertyMap.entrySet()) {
//            generator.addProperty(entry.getKey(), entry.getValue().getClass());
//        }
//
//        Object object = generator.create();
//
//        for (Map.Entry<String, Object> map : propertyMap.entrySet()) {
//            BeanUtil.setFieldValue(object, proxyPrefix + map.getKey(), map.getValue());
//        }
//
//        String objectJson = JSON.toJSONString(object).replace(proxyPrefix, CommonConstants.SPACE);
//
//        return JSON.parseObject(objectJson, Object.class);
//    }
//
//    /**
//     * 获取WinFormat的注解属性和其依赖属性
//     *
//     * @param clazz
//     * @return
//     * @throws
//     * @Title: getWinFormatField
//     * @return: Map<Field   ,   Field> Map<注解属性,依赖属性>
//     * @author: hechengcheng
//     * @Date: 2019年8月8日/上午9:13:11
//     */
//    private static Map<Field, Field> getWinFormatField(Class<?> clazz) {
//
//        Map<Field, Field> annoFieldMap = null;
//
//        // 获取类所有属性
//        List<Field> fieldList = ReflectUtil.getAllField(clazz);
//
//        if (CollectionUtil.isEmpty(fieldList)) {
//            return null;
//        }
//
//        annoFieldMap = new LinkedHashMap<Field, Field>(16);
//
//        // List转Map
//        Map<String, Field> mapField = fieldList.stream().collect(Collectors.toMap(Field::getName, a -> a, (k1, k2) -> k1));
//
//        for (Map.Entry<String, Field> entry : mapField.entrySet()) {
//
//            Field field = entry.getValue();
//
//            // 判断是否WinFormat注解
//            if (field.isAnnotationPresent(WinFormat.class)) {
//
//                WinFormat winFormat = field.getAnnotation(WinFormat.class);
//
//                annoFieldMap.put(field, mapField.get(winFormat.fromField()));
//            }
//        }
//
//        return annoFieldMap;
//    }
//
//    /**
//     * 获取WinFormatReverse的注解属性和其依赖属性
//     *
//     * @param clazz
//     * @return
//     * @throws
//     * @Title: getWinFormatReverseField
//     * @return: Map<Field   ,   Field> Map<注解属性,依赖属性>
//     * @author: zhaokai
//     * @Date: 2020年9月16日/下午8:11:33
//     */
//    private static Map<Field, Field> getWinFormatReverseField(Class<?> clazz) {
//
//        Map<Field, Field> annoFieldMap = null;
//
//        // 获取类所有属性
//        List<Field> fieldList = ReflectUtil.getAllField(clazz);
//
//        if (CollectionUtil.isEmpty(fieldList)) {
//            return null;
//        }
//
//        // List转Map
//        Map<String, Field> mapField = fieldList.stream().collect(Collectors.toMap(Field::getName, a -> a, (k1, k2) -> k1));
//
//        annoFieldMap = new LinkedHashMap<Field, Field>(16);
//
//        for (Map.Entry<String, Field> entry : mapField.entrySet()) {
//
//            Field field = entry.getValue();
//
//            // 判断是否WinFormat注解
//            if (field.isAnnotationPresent(WinFormatReverse.class)) {
//
//                WinFormatReverse winFormatReverse = field.getAnnotation(WinFormatReverse.class);
//
//                annoFieldMap.put(field, mapField.get(winFormatReverse.fromField()));
//            }
//        }
//
//        return annoFieldMap;
//    }
//
//    /**
//     * 功能描述 <br>
//     * 将bean转为Map
//     *
//     * @param bean
//     * @return java.util.Map<java.lang.String   ,   java.lang.Object>
//     * @author jinxiaolong
//     * @date 2019/10/10 11:34
//     */
//    public static <T> Map<String, Object> beanToMap(T bean) {
//        Map<String, Object> map = Maps.newHashMap();
//        if (bean != null) {
//            BeanMap beanMap = BeanMap.create(bean);
//            for (Object key : beanMap.keySet()) {
//                map.put(key + "", beanMap.get(key));
//            }
//        }
//        return map;
//    }
//
//    /**
//     * 功能描述 <br>
//     * 将Map转为Bean
//     *
//     * @param map
//     * @param bean
//     * @return T
//     * @author jinxiaolong
//     * @date 2019/10/10 11:35
//     */
//    public static <T> T mapToBean(Map<String, Object> map, T bean) {
//        BeanMap beanMap = BeanMap.create(bean);
//        beanMap.putAll(map);
//        return bean;
//    }
//
//    /**
//     * 功能描述 <br>
//     * 将List<T>转换为List<Map<String, Object>>
//     *
//     * @param objList
//     * @return java.util.List<java.util.Map   <   java.lang.String   ,   java.lang.Object>>
//     * @author jinxiaolong
//     * @date 2019/10/10 11:35
//     */
//    public static <T> List<Map<String, Object>> objectsToMaps(List<T> objList) {
//        List<Map<String, Object>> list = Lists.newArrayList();
//        if (objList != null && objList.size() > 0) {
//            Map<String, Object> map = null;
//            T bean = null;
//            for (int i = 0, size = objList.size(); i < size; i++) {
//                bean = objList.get(i);
//                map = beanToMap(bean);
//                list.add(map);
//            }
//        }
//        return list;
//    }
//
//    /**
//     * 功能描述 <br>
//     * 将List<Map<String,Object>>转换为List<T>
//     *
//     * @param maps
//     * @param clazz
//     * @return java.util.List<T>
//     * @author jinxiaolong
//     * @date 2019/10/10 11:36
//     */
//    public static <T> List<T> mapsToObjects(List<Map<String, Object>> maps, Class<T> clazz) throws InstantiationException, IllegalAccessException {
//        List<T> list = Lists.newArrayList();
//        if (maps != null && maps.size() > 0) {
//            Map<String, Object> map = null;
//            T bean = null;
//            for (int i = 0, size = maps.size(); i < size; i++) {
//                map = maps.get(i);
//                bean = clazz.newInstance();
//                mapToBean(map, bean);
//                list.add(bean);
//            }
//        }
//        return list;
//    }
//
//    /**
//     * @param obj     the object reference to check for nullity
//     * @param message detail message to be used in the event that a {@code
//     *                WinException} is thrown
//     * @param <T>     the type of the reference
//     * @return {@code obj} if not {@code null}
//     * @throws WinException if {@code obj} is {@code null}
//     */
//    public static <T> T requireNonNull(T obj, String message) {
//        if (obj == null) {
//            throw new WinException(message);
//        }
//        return obj;
//    }
//
//
//    /**
//     * @param obj           需要检验是否{@code null}的对象
//     * @param exceptionEnum 异常枚举值
//     * @param enumArgs      枚举值中msg的format参数，当{@code exceptionEnum}的msg属性为格式字符串时使用
//     * @param <T>           类型参数
//     * @return {@code obj} 如果 obj 不是 {@code null}
//     * @throws WinException 如果 {@code obj} 是 {@code null}
//     */
//    public static <T> T requireNonNull(T obj, IExceptionEnum exceptionEnum, Object... enumArgs) {
//        if (obj == null) {
//            throw WinExceptionUtil.winException(exceptionEnum, enumArgs);
//        }
//        return obj;
//    }
//}
